home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / OWLINC.PAK / SPLITTER.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  11KB  |  399 lines
  1. //----------------------------------------------------------------------------
  2. // ObjectWindows
  3. // Copyright (c) 1995, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   10.9  $
  6. //
  7. // Definition of helper classes for Pane Splitters
  8. //----------------------------------------------------------------------------
  9. #if !defined(OWL_SPLITTER_H)
  10. #define OWL_SPLITTER_H
  11.  
  12. #if !defined OWL_LAYOUTWI_H
  13. # include <owl/layoutwi.h>
  14. #endif
  15. #if !defined(CLASSLIB_LISTIMP_H)
  16. # include <classlib/listimp.h>
  17. #endif
  18. #if !defined(CLASSLIB_SHDEL_H)
  19. # include <classlib/shddel.h>
  20. #endif
  21.  
  22. #if defined(BI_NAMESPACE)
  23. namespace OWL {
  24. #endif
  25.  
  26. class _OWLCLASS TDC;
  27.  
  28. // Generic definitions/compiler options (eg. alignment) preceeding the
  29. // definition of classes
  30. #include <services/preclass.h>
  31.  
  32. //
  33. // Enumeration describing whether to split a window in the X or Y plane.
  34. //
  35. enum TSplitDirection {
  36.   psHorizontal,               // Horizontal split
  37.   psVertical,                 // Vertical split
  38.   psNone                      // Unspecified split
  39. };
  40.  
  41. class _OWLCLASS TSplitterIndicator;
  42. class _OWLCLASS TPaneSplitter;
  43.  
  44. //
  45. // class TSplitter
  46. // ~~~~~ ~~~~~~~~~
  47. // Abstract base class for TVSplitter and THSplitter.
  48. //
  49. class _OWLCLASS TSplitter : public TLayoutWindow {
  50.   public:
  51.     TSplitter(TWindow* parent, TPaneSplitter* ps, float percent);
  52.  
  53.     int                         operator ==(const TSplitter& splitter) const;
  54.     float                       GetPercent();
  55.     void                        SetPercent(float p);
  56.     virtual TRect               GetRect() = 0;
  57.     TRect                       GetScreenRect();
  58.     virtual TSplitDirection     SplitDirection() = 0;
  59.     virtual TSplitterIndicator* CreateSplitterIndicator() = 0;
  60.     virtual TWindow*            Pane1() = 0;
  61.     virtual TWindow*            Pane2() = 0;
  62.     virtual void                Split(TWindow* targetPane,
  63.                                       TWindow* newPane,
  64.                                       TSplitDirection sd,
  65.                                       float percent) = 0;
  66.     virtual TLayoutMetrics      Setup(TWindow* targetPane,
  67.                                       TWindow* newPane,
  68.                                       float percent) = 0;
  69.     virtual void                AdjForResize(const TSize& sz) = 0;
  70.     TLayoutWindow*              RemovePane(TWindow* pane,
  71.                                            TShouldDelete::DeleteType dt =
  72.                                              TShouldDelete::DefDelete);
  73.     TRect                       GetMoveArea();
  74.     virtual void                Move(int dist) = 0;
  75.     virtual void                AdjSplitterWidth(int w) = 0;
  76.  
  77.   protected:
  78.     void                        EvLButtonDown(uint modKeys, TPoint& point);
  79.     void                        EvLButtonUp(uint modKeys, TPoint& point);
  80.     void                        EvMouseMove(uint modKeys, TPoint& point);
  81.     bool                        EvSetCursor(HWND /*hWndCursor*/,
  82.                                             uint /*hitTest*/,
  83.                                             uint /*mouseMsg*/);
  84.     void                        EvSize(uint sizeType, TSize& size);
  85.     void                        Paint(TDC& dc, bool erase, TRect& rect);
  86.  
  87.     void                        SetupEpilog(TSplitter* s, TWindow* targetPane,
  88.                                             TWindow* newPane,
  89.                                             TLayoutMetrics& lmOfTargetPane,
  90.                                             TLayoutMetrics& lmOfNewPane);
  91.  
  92.   protected_data:
  93.     // Represents the percent 'pane1' is of splitter (.5, .25, etc.).
  94.     //
  95.     float          PercentOf;
  96.     TPaneSplitter* PaneSplitter;
  97.  
  98.   DECLARE_RESPONSE_TABLE(TSplitter);
  99. };
  100.  
  101. //
  102. // class TVSplitter
  103. // ~~~~~ ~~~~~~~~~~
  104. // Represents a vertical splitter.
  105. //
  106. class _OWLCLASS TVSplitter : public TSplitter {
  107.   public:
  108.     TVSplitter(TWindow* parent, TPaneSplitter* ps, float percent=50.0);
  109.  
  110.     // Pane1 is left of splitter and pane2 is right.
  111.     //
  112.     TWindow*             Pane1();
  113.     TWindow*             Pane2();
  114.     void                 Split(TWindow* targetPane, TWindow* newPane,
  115.                                TSplitDirection sd, float percent=50.0);
  116.     TLayoutMetrics       Setup(TWindow* targetPane, TWindow* newPane, float percent);
  117.     TRect                GetRect();
  118.     TSplitDirection      SplitDirection();
  119.     TSplitterIndicator*  CreateSplitterIndicator();
  120.     void                 AdjForResize(const TSize& sz);
  121.     void                 Move(int dist);
  122.     void                 AdjSplitterWidth(int w);
  123. };
  124.  
  125. //
  126. // class THSplitter
  127. // ~~~~~ ~~~~~~~~~~
  128. // Represents a horizontal splitter.
  129. //
  130. class _OWLCLASS THSplitter : public TSplitter {
  131.   public:
  132.     THSplitter(TWindow* parent, TPaneSplitter* ps, float percent=50.0);
  133.  
  134.     // Pane1 is above splitter and pane2 is below.
  135.     //
  136.     TWindow*             Pane1();
  137.     TWindow*             Pane2();
  138.     void                 Split(TWindow* targetPane, TWindow* newPane,
  139.                                TSplitDirection sd, float percent=50.0);
  140.     TLayoutMetrics       Setup(TWindow* targetPane, TWindow* newPane, float percent);
  141.     TRect                GetRect();
  142.     TSplitDirection      SplitDirection();
  143.     TSplitterIndicator*  CreateSplitterIndicator();
  144.     void                 AdjForResize(const TSize& sz);
  145.     void                 Move(int dist);
  146.     void                 AdjSplitterWidth(int w);
  147. };
  148.  
  149. //
  150. // class TSplitterIndicator
  151. // ~~~~~ ~~~~~~~~~~~~~~~~~~
  152. // Indicates to the user where the splitter will be moved to when dragging
  153. // completes. Abstract base class for TVSplitterIndicator and
  154. // THSplitterIndicator.
  155. //
  156. class _OWLCLASS TSplitterIndicator : public TRect {
  157.   public:
  158.     TSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion=0);
  159.  
  160.     int               operator == (const TSplitterIndicator& si) const;
  161.     virtual void      ConnectToRect(const TRect& rect) = 0;
  162.     virtual void      Move(int dist) = 0;
  163.     uint              GetDistMoved();
  164.     void              Draw();
  165.     void              Clear();
  166.     virtual int       CalcDistMoved(const TPoint& start, const TPoint& cur) = 0;
  167.     virtual bool      CouldContain(const TPoint& point) = 0;
  168.     TSplitter*        GetSplitter();
  169.     virtual TRect     CalcAreaOfSplitterMove() = 0;
  170.     void              SetCushion(const uint cushion);
  171.  
  172.   protected:
  173.     TSplitter*  Splitter;
  174.     bool        Showing;
  175.     uint        DistMoved;
  176.     //
  177.     // Minimum distance btwn separators.
  178.     // 
  179.     uint        Cushion;
  180. };
  181.  
  182. //
  183. // class TVSplitterIndicator
  184. // ~~~~~ ~~~~~~~~~~~~~~~~~~~
  185. // Vertical indicator.
  186. //
  187. class _OWLCLASS TVSplitterIndicator : public TSplitterIndicator {
  188.   public:
  189.     TVSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion=0);
  190.  
  191.     // Override virtuals
  192.     //
  193.     void    ConnectToRect(const TRect& rect);
  194.     void    Move(int dist);
  195.     int     CalcDistMoved(const TPoint& start, const TPoint& cur);
  196.     bool    CouldContain(const TPoint& point);
  197.     TRect   CalcAreaOfSplitterMove();
  198. };
  199.  
  200. //
  201. // class THSplitterIndicator
  202. // ~~~~~ ~~~~~~~~~~~~~~~~~~~
  203. // Horizontal indicator.
  204. //
  205. class _OWLCLASS THSplitterIndicator : public TSplitterIndicator {
  206.   public:
  207.     THSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion=0);
  208.  
  209.     // Override virtuals
  210.     //
  211.     void    ConnectToRect(const TRect& rect);
  212.     void    Move(int dist);
  213.     int     CalcDistMoved(const TPoint& start, const TPoint& cur);
  214.     bool    CouldContain(const TPoint& point);
  215.     TRect   CalcAreaOfSplitterMove();
  216. };
  217.  
  218. //
  219. // class TSplitterIndicatorList
  220. // ~~~~~ ~~~~~~~~~~~~~~~~~~~~~~
  221. class _OWLCLASS TSplitterIndicatorList : public TIListImp<TSplitterIndicator> {
  222.   public:
  223.     TSplitterIndicatorList();
  224.  
  225.     uint                NSplitterIndicators();
  226.     TSplitterIndicator* FindIndicatorWithSplitter(TSplitter* splitter);
  227. };
  228.  
  229. typedef TIListIteratorImp<TSplitterIndicator> TSplitterIndicatorListIterator;
  230.  
  231. //
  232. // class TSplitterIndicatorMgr
  233. // ~~~~~ ~~~~~~~~~~~~~~~~~~~~~
  234. // Handles the moving of the indicators.
  235. //
  236. class _OWLCLASS TSplitterIndicatorMgr {
  237.   public:
  238.     TSplitterIndicatorMgr();
  239.  
  240.     void            StartMove(TSplitterIndicatorList& sil, const TPoint& point);
  241.     void            EndMove();
  242.     void            MoveIndicators(const TPoint& point);
  243.  
  244.   private:
  245.     TSplitterIndicatorList*   SplitterIndicatorList;
  246.     TPoint                    StartDragPoint;
  247.  
  248.     void            DrawIndicators();
  249.     void            ClearIndicators();
  250. };
  251.  
  252. // Generic definitions/compiler options (eg. alignment) following the
  253. // definition of classes
  254. #include <services/posclass.h>
  255.  
  256. #if defined(BI_NAMESPACE)
  257. } // namespace OWL
  258. #endif
  259.  
  260. //----------------------------------------------------------------------------
  261. // Inline implementations
  262.  
  263. //
  264. inline int TSplitter::operator ==(const TSplitter& splitter) const
  265. {
  266.   return this == &splitter;
  267. }
  268.  
  269. //
  270. inline float TSplitter::GetPercent()
  271. {
  272.   return PercentOf;
  273. }
  274.  
  275. //
  276. inline void TSplitter::SetPercent(float p)
  277. {
  278.   PercentOf = p;
  279. }
  280.  
  281. //
  282. // Return the area the splitter can move in (bounding rectangle).
  283. // The rect is in client coordinates.
  284. //
  285. inline TRect TSplitter::GetMoveArea()
  286. {
  287.   return GetWindowRect();
  288. }
  289.  
  290. //
  291. // Similar to above except rect is in screen coordinates.
  292. //
  293. inline TRect TSplitter::GetScreenRect()
  294. {
  295.   TRect  rect = GetRect();
  296.   MapWindowPoints(0, (TPoint*)&rect, 2);  // map to screen
  297.   return rect;
  298. }
  299.  
  300. //
  301. inline TSplitDirection TVSplitter::SplitDirection()
  302. {
  303.   return psVertical;
  304. }
  305.  
  306. //
  307. inline TSplitDirection
  308. THSplitter::SplitDirection()
  309. {
  310.   return psHorizontal;
  311. }
  312.  
  313. //
  314. inline TSplitterIndicator::TSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion)
  315. :
  316.   TRect(rect), Splitter(splitter), Showing(false), DistMoved(0), Cushion(cushion)
  317. {
  318. }
  319.  
  320. //
  321. inline int TSplitterIndicator::operator ==(const TSplitterIndicator& si) const
  322. {
  323.   return this == &si;
  324. }
  325.  
  326. //
  327. inline uint
  328. TSplitterIndicator::GetDistMoved()
  329. {
  330.   return DistMoved;
  331. }
  332.  
  333. //
  334. // Clear indicator from screen.
  335. //
  336. inline void
  337. TSplitterIndicator::Clear()
  338. {
  339.   if (Showing) {
  340.     Showing = false;
  341.     Draw();
  342.     Showing = false;
  343.   }
  344. }
  345.  
  346. //
  347. // Return splitter from which this indicator was created.
  348. //
  349. inline TSplitter*
  350. TSplitterIndicator::GetSplitter()
  351. {
  352.   return Splitter;
  353. }
  354.  
  355. //
  356. // Set cushion
  357. //
  358. inline void
  359. TSplitterIndicator::SetCushion(const uint cushion)
  360. {
  361.    Cushion = cushion;
  362. }
  363.  
  364. //
  365. inline TVSplitterIndicator::TVSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion)
  366. :
  367.   TSplitterIndicator(splitter, rect, cushion)
  368. {
  369. }
  370.  
  371. //
  372. inline THSplitterIndicator::THSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion)
  373. :
  374.   TSplitterIndicator(splitter, rect, cushion)
  375. {
  376. }
  377.  
  378. //
  379. inline TSplitterIndicatorList::TSplitterIndicatorList()
  380. :
  381.   TIListImp<TSplitterIndicator>()
  382. {
  383. }
  384.  
  385. //
  386. inline uint TSplitterIndicatorList::NSplitterIndicators()
  387. {
  388.   return GetItemsInContainer();
  389. }
  390.  
  391. //
  392. inline TSplitterIndicatorMgr::TSplitterIndicatorMgr()
  393. :
  394.   SplitterIndicatorList(0)
  395. {
  396. }
  397.  
  398. #endif // OWL_SPLITTER_H
  399.